home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / HDX302.ST / GPART < prev    next >
Encoding:
Text File  |  2001-02-09  |  10.6 KB  |  491 lines
  1. /* part.c */
  2.  
  3.  
  4. /*
  5.  * 24-Nov-88    jye.     change and add codes so that can be used for MS-DOS
  6.  */
  7. #include "obdefs.h"
  8. #include "gemdefs.h"
  9. #include "osbind.h"
  10. #include "defs.h"
  11. #include "part.h"
  12. #include "bsl.h"
  13. #include "hdx.h"
  14. #include "addr.h"
  15.  
  16.  
  17. extern char sbuf[];
  18. extern int rebootp;
  19. extern int uplim;
  20. extern long bslsiz;
  21. extern long gbslsiz();
  22. extern int ibmpart;
  23. extern int toibm;
  24.  
  25. /*
  26.  * Complain about partition error.
  27.  *
  28.  */
  29. parterr(devno)
  30. int devno;
  31. {
  32.     char *pdev="X";
  33.     
  34.     *pdev = devno + '0';
  35.     (cantpart[PTNDEV].ob_spec)->te_ptext = pdev;
  36.     cantpart[PTNERROK].ob_state = NORMAL;
  37.     execform(cantpart);
  38.     return ERROR;
  39. }
  40.  
  41.  
  42. /*
  43.  * Fill in partition entry with default information
  44.  * and configuration values from the current "pr" wincap entry.
  45.  *
  46.  */
  47. fillpart(n, part)
  48. int n;
  49. PART *part;
  50. {
  51.     long num;
  52.     char *partid;
  53.     char *idstr = "XX";
  54.     char *wgetstr();
  55.  
  56.     idstr[1] = n + '0';
  57.  
  58.     part->p_flg = 0;        /* set defaults */
  59.     part->p_id[0] = 'G';
  60.     part->p_id[1] = 'E';
  61.     part->p_id[2] = 'M';
  62.     part->p_st = 0;
  63.     part->p_siz = 0;
  64.  
  65.     /* see if `pX' is mentioned */
  66.     *idstr = 'p';
  67.     if (wgetnum(idstr, &num) == OK)
  68.     {
  69.     if ((ibmpart) || (toibm))    {/* there is a extened partition */
  70.         if (n == 0)    {
  71.             part->p_siz = (LONG)(num / 512);
  72.             part->p_flg = P_EXISTS;
  73.             part->p_id[0] = 'I';
  74.             part->p_id[1] = 'B';
  75.             part->p_id[2] = 'M';
  76.         } else if (n == 1)    {
  77.             part->p_siz = (LONG)(num / 512);
  78.             part->p_flg = P_EXISTS;
  79.             part->p_id[0] = 'I';
  80.             part->p_id[1] = 'B';
  81.             part->p_id[2] = 'M';
  82.             (part+3)->p_siz = (LONG)(num / 512);
  83.             (part+3)->p_flg = P_EXISTS;
  84.             (part+3)->p_id[0] = 'I';
  85.             (part+3)->p_id[1] = 'B';
  86.             (part+3)->p_id[2] = 'M';
  87.         } else     {
  88.             (part-n+1)->p_siz += (LONG)(num / 512); /* addup ext partitions */
  89.             /* assign to ext partition number */
  90.             (part+3)->p_siz = (LONG)(num / 512);
  91.             (part+3)->p_flg = P_EXISTS;
  92.             (part+3)->p_id[0] = 'I';
  93.             (part+3)->p_id[1] = 'B';
  94.             (part+3)->p_id[2] = 'M';
  95.         }
  96.     } else { /* do the ST partition assignment */
  97.         part->p_siz = (LONG)(num / 512);
  98.         *idstr = 'f';
  99.         if (wgetnum(idstr, &num) == OK)    {
  100.             part->p_flg = (BYTE)num;
  101.         } else {
  102.             part->p_flg = P_EXISTS;
  103.         }
  104.         *idstr = 'i';
  105.         if ((partid = wgetstr(idstr)) != NULL)
  106.             for (num = 0; num < 3; ++num)
  107.                 part->p_id[num] = partid[num];
  108.     }
  109.     }
  110. }
  111.  
  112.  
  113. /*
  114.  * Extract partition structures from root sector.
  115.  *
  116.  */
  117. gpart(image, pinfo)
  118. char *image;
  119. PART *pinfo;
  120. {
  121.     register PART *rpart;
  122.     int i, j;
  123.  
  124.     rpart = &((RSECT *)(image + 0x200 - sizeof(RSECT)))->hd_p[0];
  125.  
  126.     for (i = 0; i < 4; ++i)
  127.     {
  128.     pinfo->p_flg = rpart->p_flg;
  129.     for (j = 0; j < 3; ++j)
  130.         pinfo->p_id[j] = rpart->p_id[j];
  131.     pinfo->p_st = rpart->p_st;
  132.     pinfo->p_siz = rpart->p_siz;
  133.  
  134.     ++pinfo;
  135.     ++rpart;
  136.     }
  137.     for (i = 4; i < 30; ++i)
  138.     {
  139.     pinfo->p_flg &= ~P_EXISTS;
  140.     for (j = 0; j < 3; ++j)
  141.         pinfo->p_id[j] = "x";
  142.     pinfo->p_st = 0L;
  143.     pinfo->p_siz = 0L;
  144.  
  145.     ++pinfo;
  146.     }
  147. }
  148.  
  149.  
  150. /*
  151.  * Extract partition structures from root sector.
  152.  *
  153.  */
  154. igpart(image, pinfo)
  155. char *image;
  156. PART *pinfo;
  157. {
  158.     PART *rpart;
  159.     int i, j;
  160.  
  161.     rpart = &((RSECT *)(image + 0x200 - sizeof(RSECT)))->hd_p[0];
  162.  
  163.     for (i = 0; i < NPARTS; ++i)    {
  164.         if (i == 0)    {
  165.             pinfo->p_siz = rpart->p_siz;
  166.             pinfo->p_flg = rpart->p_flg;
  167.             pinfo->p_id[0] = 'I';
  168.             pinfo->p_id[1] = 'B';
  169.             pinfo->p_id[2] = 'M';
  170.         } else if (i == 1)    {
  171.             pinfo->p_siz = rpart->p_siz;
  172.             pinfo->p_flg = rpart->p_flg;
  173.             pinfo->p_id[0] = 'I';
  174.             pinfo->p_id[1] = 'B';
  175.             pinfo->p_id[2] = 'M';
  176.             (pinfo+3)->p_siz = rpart->p_siz;
  177.             (pinfo+3)->p_flg = rpart->p_flg;
  178.             (pinfo+3)->p_id[0] = 'I';
  179.             (pinfo+3)->p_id[1] = 'B';
  180.             (pinfo+3)->p_id[2] = 'M';
  181.         } else     {
  182.             if (rpart->p_flg & P_EXISTS)    {
  183.             (pinfo-i+1)->p_siz += rpart->p_siz; /* addup ext partitions */
  184.             /* assign to ext partition number */
  185.             (pinfo+3)->p_siz = rpart->p_siz;
  186.             }
  187.             (pinfo+3)->p_flg = rpart->p_flg;
  188.             (pinfo+3)->p_id[0] = 'I';
  189.             (pinfo+3)->p_id[1] = 'B';
  190.             (pinfo+3)->p_id[2] = 'M';
  191.             pinfo->p_siz = 0L;
  192.             pinfo->p_flg = 0L;
  193.             pinfo->p_st = 0L;
  194.         }
  195.         ++pinfo;
  196.         ++rpart;
  197.     }
  198.     for (i = 7; i < 30; ++i)
  199.     {
  200.         pinfo[i].p_flg &= ~P_EXISTS;
  201.         for (j = 0; j < 3; ++j)
  202.             pinfo[i].p_id[j] = "x";
  203.         pinfo[i].p_st = 0L;
  204.         pinfo[i].p_siz = 0L;
  205.     }
  206. }
  207.  
  208.  
  209. /*
  210.  * Install partition structures in root sector.
  211.  *
  212.  */
  213. spart(image, pinfo)
  214. char *image;
  215. PART *pinfo;
  216. {
  217.     register PART *rpart;
  218.     int i, j;
  219.  
  220.     rpart = &((RSECT *)(image + 0x200 - sizeof(RSECT)))->hd_p[0];
  221.  
  222.     for (i = 0; i < 4; ++i)
  223.     {
  224.     rpart->p_flg = pinfo->p_flg;    /* copy part struct */
  225.     for (j = 0; j < 3; ++j)
  226.         rpart->p_id[j] = pinfo->p_id[j];
  227.     rpart->p_st = pinfo->p_st;
  228.     rpart->p_siz = pinfo->p_siz;
  229.  
  230.     ++rpart;
  231.     ++pinfo;
  232.     }
  233. }
  234.  
  235.  
  236. /*
  237.  * Setup partitions on the disk;
  238.  * write boot sectors and zero FATs and root directories.
  239.  *
  240.  */
  241. dopart(physdev, pinfo)
  242. int physdev;
  243. register PART *pinfo;
  244. {
  245.     int i, ldev, ret;
  246.     SECTOR data;
  247.     char image[512], *devno="X";
  248.     long ndirs;
  249.     UWORD fatsiz;
  250.     BOOT *bs;
  251.  
  252.     if ((bslsiz = gbslsiz(physdev)) < 0L) {
  253.         if (bslsiz == ERROR)
  254.             err(rootread);
  255.         return ERROR;
  256.     }
  257.         
  258.     
  259.     for (i = 0; i < NPARTS; ++i, ++pinfo) {
  260.         
  261.         /* don't care if partition does not exist */
  262.     if (!(pinfo->p_flg & P_EXISTS)) {
  263.         continue;
  264.     }
  265.  
  266.     /*
  267.      * Compute boot sector parameters.
  268.      */
  269.     if (pinfo->p_siz >= 0x10000L) {        /* partition >=? 32Mb */
  270.         *devno = i + '0';
  271.         (part2big[BGPART].ob_spec)->te_ptext = devno;
  272.         part2big[BGPARTOK].ob_state = NORMAL;
  273.         execform(part2big);
  274.         return ERROR;
  275.     }
  276.  
  277.     /*
  278.      * Install entries in boot sector image;
  279.      * force sector checksum to zero (non-executable);
  280.      * write boot sector to media.
  281.      *
  282.       *    512 bytes/sector
  283.      *    2 or 4 sectors/cluster (partition > 16Mb has 4 spc)
  284.      *    1 reserved sector (for boot)
  285.      *    2 FATs
  286.      *    ... dir slots
  287.      *    ... # sectors
  288.      *    F8 means media is a hard disk
  289.      *    ... FAT size
  290.      *
  291.      */
  292.      
  293.     /* Make a clean boot sector */
  294.     fillbuf(image, 512L, 0L);
  295.     bs = (BOOT *)image;
  296.         
  297.         /* bytes per sector */
  298.     iw((UWORD *)&bs->b_bps[0], (UWORD)512);
  299.     
  300.     /* sectors per cluster */
  301.     if (pinfo->p_siz >= 0x8000L)    /* partition >= 16Mb */
  302.         bs->b_spc = 4;
  303.     else                /* partition < 16Mb */
  304.         bs->b_spc = 2;
  305.         
  306.     /* number of reserved sectors */
  307.     iw((UWORD *)&bs->b_res[0], (UWORD)1);
  308.     
  309.     /* number of FATs */
  310.     bs->b_nfats = 2;
  311.     
  312.  
  313.     /*
  314.      * Compute root directory size
  315.      * 256 entries, plus fudge on devs > 10Mb
  316.      */
  317.     if (pinfo->p_siz < 0x5000L) ndirs = 256;
  318.     else ndirs = pinfo->p_siz / 80;    /* 1 dir entry per 80 sectors */
  319.     ndirs = (ndirs + 15) & ~15;    /* round to nearest sector */
  320.     iw((UWORD *)&bs->b_ndirs[0], (UWORD)ndirs);
  321.     
  322.     /* number of sectors on media (partition) */
  323.     iw((UWORD *)&bs->b_nsects[0], (UWORD)pinfo->p_siz);
  324.     
  325.     /* media descriptor */
  326.     bs->b_media = 0xf8;
  327.  
  328.     /*--------------------------------------------------------------*
  329.      * Compute FAT size                        *
  330.      *                                *
  331.      * Num entries to map the entire partition            *
  332.      *    = partition's size in clusters                *
  333.      *    = partition's size in sectors / spc            *
  334.      *                                *
  335.      * Num entries in FAT                        *
  336.      *    = Num entries to map partition + reserved entries    *
  337.      *    = (partition's size in sectors / spc) + 2        *
  338.      *                                *
  339.      * Num sectors FAT occupies                    *
  340.      *    = Num entries in FAT / Num entries of FAT per sector    *
  341.      *    = Num entries in FAT / (512 / 2)    <16-bit FAT>    *
  342.      *    = ((partition's size in sectors / spc) + 2) / 256 + 1    *
  343.      *                        <+1 to round up>    *
  344.      *--------------------------------------------------------------*/
  345.     fatsiz = (((pinfo->p_siz / bs->b_spc) + 2) / 256) + 1;
  346.     iw((UWORD *)&bs->b_spf[0], (UWORD)fatsiz);
  347.  
  348.      /* write the serial number to the bs */
  349.      Protobt(bs, 0x01000000, -1, -1);
  350.  
  351.     /*
  352.      * Write partition's boot sector
  353.      */
  354.     forcesum((UWORD *)image, (UWORD)0);    /* force image checksum */
  355.     if ((ret = wrsects(physdev, 1, image, (SECTOR)pinfo->p_st)) != OK) {
  356.         if (tsterr(ret) != OK)
  357.             err(bootwrit);
  358.         return ERROR;
  359.     }
  360.  
  361.     /*
  362.      * Zero the partition
  363.      */
  364.     if ((ret = zerosect(physdev, (SECTOR)(pinfo->p_st+1),
  365.              (UWORD)(fatsiz*2 + ndirs/16))) != OK) {
  366.         if (tsterr(ret) != OK)
  367.             err(hdrwrite);
  368.         return ERROR;
  369.     }
  370.              
  371.     /*
  372.      * Make first 2 entries in FATs more IBM-like.
  373.      */
  374.     if ((ret = rdsects(physdev, 1, image, (SECTOR)(pinfo->p_st+1))) != 0) {
  375.         if (tsterr(ret) != OK)
  376.             err(fatread);
  377.         return ERROR;
  378.     }
  379.     *(UWORD *)&image[0] = 0xf8ff;
  380.     *(UWORD *)&image[2] = 0xffff;
  381.     if ((ret = wrsects(physdev, 1, image, (SECTOR)(pinfo->p_st+1))) != 0 ||
  382.         (ret = wrsects(physdev, 1, image, (SECTOR)(pinfo->p_st+1+fatsiz)))
  383.         != 0) {
  384.         if (tsterr(ret) != OK)
  385.             err(fatwrite);
  386.         return ERROR;
  387.     }
  388.  
  389.     /*
  390.      * Mark bad sectors recorded in the BSL into the FATs.
  391.      * Calculating parameters:
  392.      *    ldev - from physdev and i.
  393.      *    fat0 - always equals 1.
  394.      *    fatsiz - calculated above.
  395.      *    data - starts after the boot sector, 2 FATs and rootdir.
  396.      */
  397.     if (bslsiz > 0) {
  398.         if ((ldev = phys2log(physdev, i)) == ERROR)
  399.             return parterr(physdev);
  400.         data = (SECTOR)1 + (SECTOR)(fatsiz*2) + (SECTOR)(ndirs/16);
  401.         bsl2fat(ldev, (SECTOR)1, fatsiz, data, MEDIA);
  402.     }
  403.     }
  404.     return OK;
  405. }
  406.  
  407.  
  408. /*
  409.  * Force checksum of sector image to a value
  410.  */
  411. forcesum(image, sum)
  412. UWORD *image;
  413. UWORD sum;
  414. {
  415.     register int i;
  416.     register UWORD w;
  417.  
  418.     w = 0;
  419.     for (i = 0; i < 255; ++i)
  420.     w += *image++;
  421.     *image++ = sum - w;
  422. }
  423.  
  424.  
  425. /*
  426.  * Put word in memory in 8086 byte-reversed format.
  427.  *
  428.  */
  429. iw(wp, w)
  430. UWORD *wp;
  431. UWORD w;
  432. {
  433.     char *p;
  434.  
  435.     p = (char *)wp;
  436.     p[0] = (w & 0xff);
  437.     p[1] = ((w >> 8) & 0xff);
  438. }
  439.  
  440. /*
  441.  * Put long word in memory in 8086 word-reversed format.
  442.  *
  443.  */
  444. ilong(lp, l)
  445. long *lp;
  446. long l;
  447. {
  448.     UWORD *p;
  449.  
  450.     p = (UWORD *)lp;
  451.     iw(&p[0],(UWORD)(l & 0xffff));
  452.     iw(&p[1],(UWORD)((l >> 16) & 0xffff));
  453. }
  454.  
  455. /*
  456.  * Get long word in memory, from 8086 word-reversed format.
  457.  *
  458.  */
  459. glong(al, lp)   /* al is a swaped return long word,*/
  460.                 /* lp is a to be swaped long word */
  461. long *al;
  462. long *lp;
  463.  
  464. {
  465.    char *p, *q;
  466.  
  467.     p = (char *)al;
  468.     q = (char *)lp;
  469.     p[0] = q[3];
  470.     p[1] = q[2];
  471.     p[2] = q[1];
  472.     p[3] = q[0];
  473. }
  474.  
  475. /*
  476.  * Get word in memory, from 8086 byte-reversed format.
  477.  *
  478.  */
  479. UWORD gw(wp, aw)
  480. UWORD *wp;
  481. UWORD *aw;
  482. {
  483.     char *p, *q;
  484.  
  485.     p = (char *)wp;
  486.     q = (char *)aw;
  487.     q[0] = p[1];
  488.     q[1] = p[0];
  489.     return *aw;
  490. }
  491.